
--=============================================================================--
-- 演示：https://www.bilibili.com/video/BV1uW411d7jr/?spm_id_from=333.999.0.0
-- 代码风格依旧很狂野
--=============================================================================--


--=============================================================================--
-- ■ 加载运行库
--=============================================================================--
require "Lib/engine"
 require "Sys/扩展_精灵文字"

--===============================================================================
-- ■ 初始化屏幕
--===============================================================================
引擎  = D2D_引擎.创建(读配置项("Dat/游戏信息.ini","游戏名称","游戏名称") .. "--****",40,800,600,true,true,"Dat/图标.ico")
----资源载入
--引擎:置全局音量(0)

文字2=D2D_文字.创建 ("宋体", 20,false,false, true)
文字2:置颜色(颜色_黑)

文字3=D2D_文字.创建 ("黑体", 25,true,false, true)
文字3:置颜色(颜色_红)

文字=D2D_文字.创建 ("黑体", 60,false,true, true)
文字:置颜色(颜色_红)
数字= D2D_精灵文字.创建()

血条图片=引擎:载入图片("Dat/血条.png")
特效图片=引擎:载入图片("Dat/特效.png")
背景图片1=引擎:载入图片("Dat/bg.jpg")
背景图片2=引擎:载入图片("Dat/GameBackAni_00.png")
背景图片3=引擎:载入图片("Dat/2.jpg")
背景图片4=引擎:载入图片("Dat/背景图片.png")
粒子图片 = 引擎:载入图片("Dat/particles.png")
主角图片=引擎:载入图片("Dat/飞机.png")
--子弹
大导弹图片=引擎:载入图片("Dat/大导弹.png")
主角导弹=引擎:载入图片("Dat/导弹.png")
激光图片=引擎:载入图片("Dat/激光.png")
素材杂烩=引擎:载入图片("Dat/素材杂烩.png")
--飞行的敌人
敌人图片1=引擎:载入图片("Dat/图片1.png")
敌人图片2=引擎:载入图片("Dat/图片2.png")
敌人图片4=引擎:载入图片("Dat/敌人.png")
敌人图片5=引擎:载入图片("Dat/敌人1.png")
敌人图片3=引擎:载入图片("Dat/sprites.png")
--其他敌人
敌人图片8=引擎:载入图片("Dat/底座.png")
敌人图片9=引擎:载入图片("Dat/炮筒.png")
--敌人boss
敌人={}
敌人[0]=引擎:载入图片("Dat/enemy0.png")
敌人[1]=引擎:载入图片("Dat/enemy1.png")
敌人[2]=引擎:载入图片("Dat/enemy2.png")
敌人[3]=引擎:载入图片("Dat/enemy3.png")
敌人[4]=引擎:载入图片("Dat/enemy4.png")
--敌人子弹

子弹图片2=引擎:载入图片("Dat/蛇身.png")
子弹图片1=引擎:载入图片("Dat/white-ball.png")
子弹图片3=引擎:载入图片("Dat/bullet.png")

开启音效= D2D_音效.创建("Dat/鹰.MP3")
开启音效:播放()
变身音效= D2D_音效.创建("Dat/丝.mp3")
报警音效= D2D_音效.创建("Dat/报警.wav")
子弹音效1= D2D_音效.创建("Dat/机枪.ogg")
子弹音效2= D2D_音效.创建"Dat/m 枪.wav"
子弹音效3= D2D_音效.创建("Dat/s 枪.wav")
子弹音效4= D2D_音效.创建("Dat/火箭.mp3")
子弹音效5= D2D_音效.创建("Dat/火焰.wav")
激光音效= D2D_音效.创建("Dat/激光.mp3")
胜利音效= D2D_音效.创建("Dat/胜.mp3")
失败音效= D2D_音效.创建("Dat/WAV2.WAV")
爆炸音效= D2D_音效.创建("Dat/WAV3.WAV")
升级音效= D2D_音效.创建("Dat/奖金.wav")
背景音乐=D2D_音效.创建("Dat/FirstStepMaster.mp3")
背景音乐:播放_高级(20,true,1)

----素材创建
--特效
变身特效组={}
激光特效组={}
弹幕特效组={}
爆炸特效组={}
倒计时b=100

--背景
背景精灵={}
背景精灵[1]= D2D_精灵.创建(背景图片1,0,0,800,600)
背景精灵[2]= D2D_精灵.创建(背景图片2,0,0,800,600)
背景精灵[3]= D2D_精灵.创建(背景图片3,0,0,800,600)
背景精灵[4]= D2D_精灵.创建(背景图片4,0,0,800,600)


---------主角信息
主角动画=D2D_动画.创建(主角图片,6,4,0,0,100,100)
主角动画:播放()
主角动画:置中心点(50,50)

主角包围盒=D2D_包围盒.创建(0,0,60,60)

主角={
	x=400,
	y=400,
	血量=40,
	状态="",
	射速=30,		
	子弹等级=2,
	子弹威力=1,
	防御=1
}
主角子弹组={}

主角子弹1= D2D_精灵.创建(素材杂烩,60,0,10,20)
主角子弹1:置中心点(5,5)
主角子弹2 = D2D_精灵.创建(粒子图片,96, 32, 32, 32)
主角子弹2:置中心点(16,16)

爆炸= D2D_精灵.创建(粒子图片,96, 32, 32, 32)
爆炸:置中心点(16,16)
爆炸:置混合模式(1)

当前子弹=主角子弹1
当前射速=0

临时x=0
临时y=0

------主角副武器------

血条前景= D2D_精灵.创建(血条图片,14,0,6,96)
血条背景= D2D_精灵.创建(血条图片,0,0,10,100)

血量=0
武器升级=0

特效=D2D_粒子.创建("Dat/特效.psi",主角子弹2)
副武器参数=0

血条前景1= D2D_精灵.创建(血条图片1,14,0,6,96)
血条背景1= D2D_精灵.创建(血条图片,0,0,10,100)
血条前景1:置颜色(ARGB(255,0,0,255))
----召唤卫星

卫星底座2= D2D_精灵.创建(素材杂烩,70,0,28,28)
卫星底座2:置中心点(14,14)
卫星炮2= D2D_精灵.创建(素材杂烩,110,0,18,36)
卫星炮2:置中心点(9,9)
卫星底座1= D2D_精灵.创建(敌人图片8,0,0,32,32)
卫星底座1:置中心点(16,16)
卫星炮1= D2D_精灵.创建(敌人图片9,0,0,32,32)
卫星炮1:置中心点(16,16)

卫星子弹组={}

卫星={x=0,y=0,d=0}
卫星1={攻击倒计时=0}
卫星2={攻击倒计时=0}

卫星倒计时=0

----防盾

防盾精灵= D2D_精灵.创建(特效图片,0,0,100,100)
防盾精灵:置中心点(50,50)
防盾倒计时=0
防盾=0
----激光
激光精灵= D2D_精灵.创建(激光图片,0,0,40,100)
激光精灵:置中心点(20,0)
激光倒计时=0









----敌人----
敌人组={}	--x，y，类型,显示,移动类型,m,d
						----攻击类型,血量,临时
敌人产生时间=0
敌人产生临时2=引擎:取随机整数(30,50)
敌人产生临时=0

敌人子弹组={} --x，y，d，m，射程，攻击力





----数据初始
背景参数2=引擎:取随机整数(1,4)
游戏状态=""
当前关卡=1
关卡时间=0
敌人系数=0

----可不初始数据
背景参数1x=0
背景参数1y=0

----不可初始数据
P= 0.017453


--===============================================================================
-- ■ 屏幕逻辑()
--===============================================================================
function 屏幕逻辑 ()
	时间=引擎:取最后帧时间()
	
	主角动画:更新(时间)
	
	
	
	----移动命令--移植自前作----
if(引擎:取按键事件(键_A)and(主角.x>50))then
    主角.x=主角.x-2
    背景参数1x=背景参数1x-1
end
if(引擎:取按键事件(键_D)and(主角.x<750))then
    主角.x=主角.x+2
    背景参数1x=背景参数1x+1
end
if(引擎:取按键事件(键_W)and(主角.y>50))then
    主角.y=主角.y-2
    背景参数1y=背景参数1y-0.7
end
if(引擎:取按键事件(键_S)and(主角.y<550))then
     主角.y=主角.y+2
     背景参数1y=背景参数1y+0.5
end
	----
	
	
	return false
end




--===============================================================================
-- ■ 屏幕渲染()
--===============================================================================
function 屏幕渲染 ()
	渲染开始()
	清屏(ARGB(255,128,128,128))
	--背景--
	背景精灵[背景参数2]:显示()
	背景精灵[背景参数2]:置显示区域(背景参数1x,背景参数1y,800,600)
	背景参数1y=背景参数1y-1
	
	--
	if(游戏状态=="")then
		for n=1,table.getn(变身特效组) do
			table.remove(变身特效组,n)
			break
		end
		for n=1,table.getn(激光特效组) do
			table.remove(激光特效组,n)
			break
		end
		for n=1,table.getn(弹幕特效组) do
			table.remove(弹幕特效组,n)
			break
		end
		for n=1,table.getn(爆炸特效组) do
			table.remove(爆炸特效组,n)
			break
		end
		for n=1,table.getn(主角子弹组) do
			table.remove(主角子弹组,n)
			break
		end
		for n=1,table.getn(卫星子弹组) do
			table.remove(卫星子弹组,n)
			break
		end
		for n=1,table.getn(敌人组) do
			table.remove(敌人组,n)
			break
		end
		for n=1,table.getn(敌人子弹组) do
			table.remove(敌人子弹组,n)
			break
		end
		文字2:显示(210,340,"W上S下A左D右,空格技能,按回车开始!")
		文字:显示(210,270,"当前关卡:")
		数字:显示(当前关卡,480,270,60,65,255,false)
		if(引擎:取按键按下(键_回车))then
			
			--初始
			关卡时间=0
			敌人系数=0
			敌人产生时间=0
			敌人产生临时2=引擎:取随机整数(30,50)
			敌人产生临时=0
			背景参数2=引擎:取随机整数(1,4)
			最后敌人=0
			if(主角.血量>30)then
				主角.血量=40
			else
				主角.血量=主角.血量+10
			end
			主角.x=400
			主角.y=400
			倒计时b=100
			for n=1,table.getn(变身特效组) do
				table.remove(变身特效组,n)
				break
			end
			for n=1,table.getn(激光特效组) do
				table.remove(激光特效组,n)
				break
			end
			for n=1,table.getn(弹幕特效组) do
				table.remove(弹幕特效组,n)
				break
			end
			for n=1,table.getn(爆炸特效组) do
				table.remove(爆炸特效组,n)
				break
			end
			for n=1,table.getn(主角子弹组) do
				table.remove(主角子弹组,n)
				break
			end
			for n=1,table.getn(卫星子弹组) do
				table.remove(卫星子弹组,n)
				break
			end
			for n=1,table.getn(敌人组) do
				table.remove(敌人组,n)
				break
			end
			for n=1,table.getn(敌人子弹组) do
				table.remove(敌人子弹组,n)
				break
			end
			
			if(table.getn(敌人子弹组)==0)and(table.getn(敌人组)==0)and(table.getn(主角子弹组)==0)and(table.getn(卫星子弹组)==0)and(table.getn(爆炸特效组)==0)and(table.getn(激光特效组)==0)and(table.getn(变身特效组)==0)and(table.getn(弹幕特效组)==0)then
				游戏状态="战斗"
			end
			
		end
	end
	
	
	if(游戏状态=="胜利")then
		for n=1,table.getn(变身特效组) do
			table.remove(变身特效组,n)
			break
		end
		for n=1,table.getn(激光特效组) do
			table.remove(激光特效组,n)
			break
		end
		for n=1,table.getn(弹幕特效组) do
			table.remove(弹幕特效组,n)
			break
		end
		for n=1,table.getn(爆炸特效组) do
			table.remove(爆炸特效组,n)
			break
		end
		for n=1,table.getn(主角子弹组) do
			table.remove(主角子弹组,n)
			break
		end
		for n=1,table.getn(卫星子弹组) do
			table.remove(卫星子弹组,n)
			break
		end
		for n=1,table.getn(敌人组) do
			table.remove(敌人组,n)
			break
		end
		for n=1,table.getn(敌人子弹组) do
			table.remove(敌人子弹组,n)
			break
		end
		文字:显示(120,270,"!恭喜通关!按空格继续!")
		if(引擎:取按键按下(键_空格))then
			--初始
			当前关卡=1
			关卡时间=0
			敌人系数=0
			敌人产生时间=0
			敌人产生临时2=引擎:取随机整数(30,50)
			敌人产生临时=0
			背景参数2=引擎:取随机整数(1,4)
			最后敌人=0
			if(主角.血量>30)then
				主角.血量=40
			else
				主角.血量=主角.血量+10
			end
			主角.x=400
			主角.y=400
			倒计时b=100
			for n=1,table.getn(变身特效组) do
				table.remove(变身特效组,n)
				break
			end
			for n=1,table.getn(激光特效组) do
				table.remove(激光特效组,n)
				break
			end
			for n=1,table.getn(弹幕特效组) do
				table.remove(弹幕特效组,n)
				break
			end
			for n=1,table.getn(爆炸特效组) do
				table.remove(爆炸特效组,n)
				break
			end
			for n=1,table.getn(主角子弹组) do
				table.remove(主角子弹组,n)
				break
			end
			for n=1,table.getn(卫星子弹组) do
				table.remove(卫星子弹组,n)
				break
			end
			for n=1,table.getn(敌人组) do
				table.remove(敌人组,n)
				break
			end
			for n=1,table.getn(敌人子弹组) do
				table.remove(敌人子弹组,n)
				break
			end
			
			if(table.getn(敌人子弹组)==0)and(table.getn(敌人组)==0)and(table.getn(主角子弹组)==0)and(table.getn(卫星子弹组)==0)and(table.getn(爆炸特效组)==0)and(table.getn(激光特效组)==0)and(table.getn(变身特效组)==0)and(table.getn(弹幕特效组)==0)then
				游戏状态="战斗"
			end
			
		end
	end
	--
	
	
if(游戏状态=="战斗")then
	----战斗代码
	关卡时间=关卡时间+1

	----死亡重开
	if(主角.血量<=0)then
		失败音效:播放()
		当前关卡=1
		游戏状态=""
	end
	
	
	主角动画:显示(主角.x,主角.y)
	主角包围盒:置位置(主角.x-30,主角.y-30)

	血条背景:显示_高级(0,600,270*P,2,2)
	血条前景:显示_高级(4,595,270*P,2,主角.血量*2/40)
	
	
	----主角射击系统----
	if(当前射速>0)then
		当前射速=当前射速-1
	else
		if(主角.子弹威力>4)then
			if(主角.子弹等级%2==1)then
				local 子弹={
					x=主角.x,
					y=主角.y-80,
					类型2=D2D_粒子.创建("Dat/烟2.psi",主角子弹2),
					类型= D2D_动画.创建(大导弹图片,4,4,20,0,15,40),
					威力=主角.子弹威力
				}
				子弹.类型:播放()
				table.insert(主角子弹组,子弹)
				for n=1,取整(主角.子弹等级/2) do
					local 子弹={
						x=主角.x+n*20,
						y=主角.y-80+5*n,
						类型2=D2D_粒子.创建("Dat/烟2.psi",主角子弹2),
						类型= D2D_动画.创建(大导弹图片,4,4,20,0,15,40),
						威力=主角.子弹威力
					}
					子弹.类型:播放()
					table.insert(主角子弹组,子弹)
					local 子弹={
						x=主角.x-n*20,
						y=主角.y-80+5*n,
						类型2=D2D_粒子.创建("Dat/烟2.psi",主角子弹2),
						类型=  D2D_动画.创建(大导弹图片,4,4,20,0,15,40),
						威力=主角.子弹威力
					}
					子弹.类型:播放()
					table.insert(主角子弹组,子弹)
				end
			else
				for n=1,取整(主角.子弹等级/2) do
					local 子弹={
						x=主角.x-10+n*20,
						y=主角.y-80+5*n,
						类型2=D2D_粒子.创建("Dat/烟2.psi",主角子弹2),
						类型=  D2D_动画.创建(大导弹图片,4,4,20,0,15,40),
						威力=主角.子弹威力
					}
					子弹.类型:播放()
					table.insert(主角子弹组,子弹)
					local 子弹={
						x=主角.x+10-n*20,
						y=主角.y-80+5*n,
						类型2=D2D_粒子.创建("Dat/烟2.psi",主角子弹2),
						类型= D2D_动画.创建(大导弹图片,4,4,20,0,15,40),
						威力=主角.子弹威力
					}
					子弹.类型:播放()
					table.insert(主角子弹组,子弹)
				end
			end
			子弹音效5:播放_高级(40,false,2)
		elseif(主角.子弹威力>3)then
			if(主角.子弹等级%2==1)then
				local 子弹={
					x=主角.x,
					y=主角.y-80,
					类型2=D2D_粒子.创建("Dat/烟.psi",主角子弹2),
					类型= D2D_精灵.创建(大导弹图片,0,0,15,40),
					威力=主角.子弹威力
				}
				table.insert(主角子弹组,子弹)
				for n=1,取整(主角.子弹等级/2) do
					local 子弹={
						x=主角.x+n*20,
						y=主角.y-80+5*n,
						类型2=D2D_粒子.创建("Dat/烟.psi",主角子弹2),
						类型= D2D_精灵.创建(大导弹图片,0,0,15,40),
						威力=主角.子弹威力
					}
					table.insert(主角子弹组,子弹)
					local 子弹={
						x=主角.x-n*20,
						y=主角.y-80+5*n,
						类型2=D2D_粒子.创建("Dat/烟.psi",主角子弹2),
						类型= D2D_精灵.创建(大导弹图片,0,0,15,40),
						威力=主角.子弹威力
					}
					table.insert(主角子弹组,子弹)
				end
			else
				for n=1,取整(主角.子弹等级/2) do
					local 子弹={
						x=主角.x-10+n*20,
						y=主角.y-80+5*n,
						类型2=D2D_粒子.创建("Dat/烟.psi",主角子弹2),
						类型= D2D_精灵.创建(大导弹图片,0,0,15,40),
						威力=主角.子弹威力
					}
					table.insert(主角子弹组,子弹)
					local 子弹={
						x=主角.x+10-n*20,
						y=主角.y-80+5*n,
						类型2=D2D_粒子.创建("Dat/烟.psi",主角子弹2),
						类型= D2D_精灵.创建(大导弹图片,0,0,15,40),
						威力=主角.子弹威力
					}
					table.insert(主角子弹组,子弹)
				end
			end
			子弹音效4:播放_高级(40,false,3)
		elseif(主角.子弹威力>2)then
			if(主角.子弹等级%2==1)then
				local 子弹={
					x=主角.x,
					y=主角.y-80,
					类型=D2D_粒子.创建("Dat/小火球.psi",主角子弹2),
					威力=主角.子弹威力
				}
				table.insert(主角子弹组,子弹)
				for n=1,取整(主角.子弹等级/2) do
					local 子弹={
						x=主角.x+n*20,
						y=主角.y-80+5*n,
						类型=D2D_粒子.创建("Dat/小火球.psi",主角子弹2),
						威力=主角.子弹威力
					}
					table.insert(主角子弹组,子弹)
					local 子弹={
						x=主角.x-n*20,
						y=主角.y-80+5*n,
						类型=D2D_粒子.创建("Dat/小火球.psi",主角子弹2),
						威力=主角.子弹威力
					}
					table.insert(主角子弹组,子弹)
				end
			else
				for n=1,取整(主角.子弹等级/2) do
					local 子弹={x=主角.x-10+n*20,
						y=主角.y-80+5*n,
						类型=D2D_粒子.创建("Dat/小火球.psi",主角子弹2),
						威力=主角.子弹威力
					}
					table.insert(主角子弹组,子弹)
					local 子弹={
						x=主角.x+10-n*20,
						y=主角.y-80+5*n,
						类型= D2D_粒子.创建("Dat/小火球.psi",主角子弹2),
						威力=主角.子弹威力
					}
					table.insert(主角子弹组,子弹)
				end
			end
			子弹音效3:播放_高级(40,false,1.5)
		elseif(主角.子弹威力>1)then
			if(主角.子弹等级%2==1)then
				local 子弹={
					x=主角.x,
					y=主角.y-80,
					类型=D2D_动画.创建(主角导弹,4,4,0,0,15,40),
					威力=主角.子弹威力
				}
				子弹.类型:播放()
				table.insert(主角子弹组,子弹)
				for n=1,取整(主角.子弹等级/2) do
					local 子弹={
						x=主角.x+n*20,
						y=主角.y-80+5*n,
						类型=D2D_动画.创建(主角导弹,4,4,0,0,15,40),
						威力=主角.子弹威力
					}
					子弹.类型:播放()
					table.insert(主角子弹组,子弹)
					local 子弹={
						x=主角.x-n*20,
						y=主角.y-80+5*n,
						类型=D2D_动画.创建(主角导弹,4,4,0,0,15,40),
						威力=主角.子弹威力
					}
					子弹.类型:播放()
					table.insert(主角子弹组,子弹)
				end
			else
				for n=1,取整(主角.子弹等级/2) do
					local 子弹={
						x=主角.x-10+n*20,
						y=主角.y-80+5*n,
						类型=D2D_动画.创建(主角导弹,4,4,0,0,15,40),
						威力=主角.子弹威力
					}
					子弹.类型:播放()
					table.insert(主角子弹组,子弹)
					local 子弹={
						x=主角.x+10-n*20,
						y=主角.y-80+5*n,
						类型=D2D_动画.创建(主角导弹,4,4,0,0,15,40),
						威力=主角.子弹威力
					}
					子弹.类型:播放()
					table.insert(主角子弹组,子弹)
				end
			end
			子弹音效2:播放_高级(40,false,1.5)
		else
			if(主角.子弹等级%2==1)then
				local 子弹={
					x=主角.x,
					y=主角.y-80,
					类型= D2D_精灵.创建(素材杂烩,0,0,14,40),
					威力=主角.子弹威力
				}
				table.insert(主角子弹组,子弹)
				for n=1,取整(主角.子弹等级/2) do
					local 子弹={
						x=主角.x+n*20,
						y=主角.y-80+5*n,
						类型= D2D_精灵.创建(素材杂烩,0,0,14,40),
						威力=主角.子弹威力
					}
					table.insert(主角子弹组,子弹)
					local 子弹={
						x=主角.x-n*20,
						y=主角.y-80+5*n,
						类型= D2D_精灵.创建(素材杂烩,0,0,14,40),
						威力=主角.子弹威力
					}
					table.insert(主角子弹组,子弹)
				end
			else
				for n=1,取整(主角.子弹等级/2) do
					local 子弹={
						x=主角.x-10+n*20,
						y=主角.y-80+5*n,
						类型= D2D_精灵.创建(素材杂烩,0,0,14,40),
						威力=主角.子弹威力
					}
					table.insert(主角子弹组,子弹)
					local 子弹={
						x=主角.x+10-n*20,
						y=主角.y-80+5*n,
						类型= D2D_精灵.创建(素材杂烩,0,0,14,40),
						威力=主角.子弹威力
					}
					table.insert(主角子弹组,子弹)
				end
			end
			子弹音效1:播放_高级(40,false,1.5)
		end
		
		当前射速=主角.射速
	end
	----主角子弹显示----
	for n=1,table.getn(主角子弹组) do
		if(主角子弹组[n].威力>4)then
			主角子弹组[n].类型:更新(时间)
			主角子弹组[n].类型2:启动到(主角子弹组[n].x,主角子弹组[n].y)
			主角子弹组[n].类型2:更新(时间)
			主角子弹组[n].类型2:显示(主角子弹组[n].x,主角子弹组[n].y)
			主角子弹组[n].类型:显示(主角子弹组[n].x-7,主角子弹组[n].y)
		elseif(主角子弹组[n].威力>3)then
			主角子弹组[n].类型2:启动到(主角子弹组[n].x,主角子弹组[n].y+40)
			主角子弹组[n].类型2:更新(时间)
			主角子弹组[n].类型2:显示(主角子弹组[n].x,主角子弹组[n].y+40)
			主角子弹组[n].类型:显示(主角子弹组[n].x-7,主角子弹组[n].y)
		elseif(主角子弹组[n].威力>2)then
			主角子弹组[n].类型:启动到(主角子弹组[n].x,主角子弹组[n].y)
			主角子弹组[n].类型:更新(时间)
			主角子弹组[n].类型:显示(主角子弹组[n].x-7,主角子弹组[n].y)
		elseif(主角子弹组[n].威力>1)then
			主角子弹组[n].类型:更新(时间)
			主角子弹组[n].类型:显示(主角子弹组[n].x-7,主角子弹组[n].y)
		else 
			主角子弹组[n].类型:显示_高级(主角子弹组[n].x-4,主角子弹组[n].y,0,0.7,0.7)
		end
		
		主角子弹组[n].y=主角子弹组[n].y-3
		
		
		----命中判断--在敌人组中--
		
		----
		
		if(主角子弹组[n].y<0)then
			table.remove(主角子弹组,n)
			break
		end
	end
	
	--主角副武器--
	血条背景1:显示_高级(600,600,270*P,2,2)
	血条前景1:显示_高级(604,595,270*P,2,血量*2/100)
	if(血量<100)then
		血量=血量+0.02
	else
		if(主角.子弹威力*主角.子弹等级<25)then
			文字3:显示(350,280,"!武器正在升级!")
			武器升级=武器升级+0.5
			if(武器升级>100)then
				if(主角.子弹等级>4)then
					主角.子弹威力=主角.子弹威力+1
					主角.子弹等级=2
				else
					主角.子弹等级=主角.子弹等级+1
				end
				主角.防御=主角.防御+0.1
				副武器参数=25
				血量=0
				武器升级=0
				升级音效:播放()
			end
		end
	end
	--副武器判断--
	if(引擎:取按键按下(键_空格))then
		if(血量>75)then
			卫星倒计时=500
			血量=0
			副武器参数=25
			升级音效:播放_高级(40,false,2)
		elseif(血量>50)then
			激光音效:播放_高级(100,false,1)
			激光倒计时=200
			血量=0
			副武器参数=25
			升级音效:播放_高级(40,false,2)
		elseif(血量>25)then
			防盾倒计时=250
			血量=0
			副武器参数=25
			升级音效:播放_高级(40,false,2)
		end
	end
	if(血量>75)and(血量<76)then
		文字3:显示(350,280,"!双子卫星就绪!")
	elseif(血量>50)and(血量<51)then
		文字3:显示(350,280,"!激光火焰就绪!")
	elseif(血量>25)and(血量<26)then
		文字3:显示(350,280,"!粒子护盾就绪!")
	end
	if(副武器参数>0)then
		特效:启动到(主角.x,主角.y)
		特效:更新(时间)
		特效:显示(主角.x,主角.y)
		副武器参数=副武器参数-1
	end
	--副武器显示--
	--防盾
	if(防盾倒计时>0)then
		防盾=1
		防盾倒计时=防盾倒计时-1
		防盾精灵:显示_高级(主角.x,主角.y,引擎:取随机小数(0,3.14),1,1)
		防盾精灵:置颜色(ARGB(引擎:取随机整数(100,200),引擎:取随机整数(1,255),引擎:取随机整数(1,255),引擎:取随机整数(1,255)))
	else
		防盾=0
	end
	
	
	--激光
	if(激光倒计时>0)then
		激光倒计时=激光倒计时-1
		激光精灵:显示_高级(主角.x,0,0,引擎:取随机小数(0,1),6)
		--命中
		for r=1,table.getn(敌人组) do
			if(敌人组[r].x+50>主角.x)and(敌人组[r].x-50<主角.x)then
				敌人组[r].血量=敌人组[r].血量-0.05
			end
		end
	end
	if(激光倒计时%40==1)then
		for r=1,table.getn(敌人组) do
			if(敌人组[r].x+50>主角.x)and(敌人组[r].x-50<主角.x)then
				local 临时爆炸={
					x=敌人组[r].x+引擎:取随机整数(-10,10),
					y=敌人组[r].y+引擎:取随机整数(-10,10),
					类型=D2D_粒子.创建("Dat/爆炸.psi",爆炸),
					倒计时=25
				}
			table.insert(爆炸特效组,临时爆炸)
				敌人组[r].血量=敌人组[r].血量-0.05
			end
		end
	end
	
	
	--卫星
	if(卫星倒计时>0)then
		卫星倒计时=卫星倒计时-1
		卫星.d=卫星.d+2
		卫星.x,卫星.y=取移动步幅(卫星.d)
		卫星底座1:显示_高级(主角.x+卫星.x*100,主角.y+卫星.y*100,卫星.d*P,1,1)
		卫星底座2:显示_高级(主角.x-卫星.x*100,主角.y-卫星.y*100,0,1,1)
		卫星炮1:显示_高级(主角.x+卫星.x*100,主角.y+卫星.y*100,卫星1.d,1,1)
		卫星炮2:显示_高级(主角.x-卫星.x*100,主角.y-卫星.y*100,(卫星.d+90)*P,1,1)
		if(卫星1.攻击倒计时>0)then
			卫星1.攻击倒计时=卫星1.攻击倒计时-1
		else
			local 子弹={
				x2=0,
				y2=0,
				x=主角.x+卫星.x*100-10,
				y=主角.y+卫星.y*100-13,
				射速=6,
				d=-90,
				类型= D2D_精灵.创建(子弹图片3,0,0,24,24),
				威力=1,
				射程=600
			}
			子弹.类型:置中心点(12,12)
			子弹.类型:置颜色(ARGB(255,引擎:取随机整数(1,255),引擎:取随机整数(1,255),引擎:取随机整数(1,255)))
			table.insert(卫星子弹组,子弹)
			子弹音效1:播放()
			local 子弹={
				x2=0,
				y2=0,
				x=主角.x+卫星.x*100+10,
				y=主角.y+卫星.y*100-13,
				射速=6,
				d=-90,
				类型= D2D_精灵.创建(子弹图片3,0,0,24,24),
				威力=3,
				射程=600
			}
			子弹.类型:置中心点(12,12)
			子弹.类型:置颜色(ARGB(255,引擎:取随机整数(1,255),引擎:取随机整数(1,255),引擎:取随机整数(1,255)))
			table.insert(卫星子弹组,子弹)
			卫星1.攻击倒计时=5
		end
		if(卫星2.攻击倒计时>0)then
			卫星2.攻击倒计时=卫星2.攻击倒计时-1
		else
			local 子弹={
				x2=0,
				y2=0,
				x=主角.x-卫星.x*130,
				y=主角.y-卫星.y*130,
				射速=6,
				d=卫星.d+220,
				类型= D2D_精灵.创建(子弹图片1,0,0,16,16),
				威力=4,
				射程=600
			}
			--子弹.类型:置中心点(8,8)
			子弹.类型:置颜色(ARGB(255,引擎:取随机整数(1,255),引擎:取随机整数(1,255),引擎:取随机整数(1,255)))
			table.insert(卫星子弹组,子弹)
			子弹音效1:播放()
			卫星2.攻击倒计时=10
		end
		
	end
	
	for n=1,table.getn(卫星子弹组) do
		卫星子弹组[n].类型:显示_高级(卫星子弹组[n].x,卫星子弹组[n].y,(卫星子弹组[n].d-90)*P,1,1)
		卫星子弹组[n].x2,卫星子弹组[n].y2=取移动步幅(卫星子弹组[n].d)
		if(卫星子弹组[n].射程>0)then
			卫星子弹组[n].x=卫星子弹组[n].x+卫星子弹组[n].射速*卫星子弹组[n].x2
			卫星子弹组[n].y=卫星子弹组[n].y+卫星子弹组[n].射速*卫星子弹组[n].y2
			卫星子弹组[n].射程=卫星子弹组[n].射程-卫星子弹组[n].射速
		else
			table.remove(卫星子弹组,n)
			break
		end
	end
	
	if(主角.血量<10)and(倒计时b<0)then
			local 临时爆炸={
				x=主角.x+引擎:取随机整数(-10,10),
				y=主角.y+引擎:取随机整数(-10,10),
				类型=D2D_粒子.创建("Dat/爆炸.psi",爆炸),
				倒计时=25
			}
			table.insert(爆炸特效组,临时爆炸)
		倒计时b=40
	else
		倒计时b=倒计时b-1
	end
	
	
	----普通敌人----
	if(关卡时间>(敌人产生时间+敌人产生临时2))and(最后敌人==0)then
		--产生敌人--要改--
		敌人产生临时=tonumber(读配置项("Dat/配置.ini",tostring(当前关卡),tostring(敌人系数)))
		敌人系数=敌人系数+1
		
		---关卡判断----
		if(敌人产生临时==0)then
			报警音效:播放()
		end
		if(敌人产生临时==-1)then
			最后敌人=1
		end
		----
		
		if(敌人产生临时==1)then
			local 敌人={
				x=引擎:取随机整数(100,700),
				y=-200,
				d=0,
				m=1,
				移动x=0,
				移动y=0,
				攻击类型="发子弹1",
				移动类型="直线飞行",
				血量=6*当前关卡,
				显示= D2D_精灵.创建(敌人图片2,0,0,100,100),
				临时=引擎:取随机整数(300,400),
				状态=0,
				类型=1
			}
			敌人.显示:置中心点(50,50)
			table.insert(敌人组,敌人)
		end
		if(敌人产生临时==2)then
			local 敌人={
				y=引擎:取随机整数(100,300),
				x=引擎:取随机整数(50,750),
				d=0,
				m=0.7,
				移动x=0,
				移动y=0,
				攻击类型="发子弹2",
				移动类型="静止",
				血量=25*当前关卡,
				显示= D2D_精灵.创建(敌人图片1,0,0,200,200),
				临时=0,
				状态=0,
				类型=2
			}
			敌人.显示:置中心点(100,100)
			table.insert(敌人组,敌人)
		end
		if(敌人产生临时==3)then
			local 敌人={
				x=引擎:取随机整数(100,700),
				y=-200,
				d=180*P,
				m=1,
				移动x=0,
				移动y=0,
				攻击类型="变身", --转为冲撞
				移动类型="直线飞行",
				血量=6*当前关卡,
				显示=D2D_动画.创建(敌人图片5,2,2,500,0,100,100),
				临时=引擎:取随机整数(300,400),
				状态=0,
				类型=3
			}
			敌人.显示:置中心点(50,50)
			table.insert(敌人组,敌人)
		end
		if(敌人产生临时==4)then
			local 敌人={
				x=引擎:取随机整数(100,700),
				y=-200,
				d=180*P,
				m=1,
				移动x=0,
				移动y=0,
				攻击类型="变身", --变身后转为发子弹2
				移动类型="直线飞行",
				血量=35*当前关卡,
				显示=D2D_动画.创建(敌人图片5,2,2,0,0,100,100),
				临时=引擎:取随机整数(300,400),
				状态=0,
				类型=4
			}
			敌人.显示:置中心点(50,50)
			table.insert(敌人组,敌人)
		end
		if(敌人产生临时==5)then
			local 敌人={
				x=引擎:取随机整数(100,700),
				y=-200,
				d=180*P,
				m=1,
				移动x=0,
				移动y=0,
				攻击类型="变身",--变身后转为激光
				移动类型="直线飞行",
				血量=30*当前关卡,
				显示=D2D_动画.创建(敌人图片5,2,2,200,0,100,100),
				临时=引擎:取随机整数(300,400),
				状态=0,
				类型=5
			}
			敌人.显示:置中心点(50,50)
			table.insert(敌人组,敌人)
		end
		if(敌人产生临时==6)then
			local 敌人={
				x=引擎:取随机整数(50,750),
				y=引擎:取随机整数(100,300),
				d=180*P,
				m=1,
				移动x=0,
				移动y=0,
				攻击类型="发子弹2",
				移动类型="静止",
				血量=40*当前关卡,
				显示=D2D_动画.创建(敌人图片4,4,4,0,0,100,100),
				临时=0,
				状态=0,
				类型=6
			}
			敌人.显示:置中心点(50,50)
			敌人.显示:播放()
			table.insert(敌人组,敌人)
		end
		if(敌人产生临时==7)then
			local 敌人={
				x=引擎:取随机整数(50,750),
				y=-200,
				d=90*P,
				m=100/64,
				移动x=0,
				移动y=0,
				攻击类型="发子弹3",
				移动类型="直线飞行",
				血量=10*当前关卡,
				显示= D2D_动画.创建(敌人图片3,3,3,0,0,64,64),
				临时=引擎:取随机整数(300,400),
				状态=0,
				类型=7
			}
			敌人.显示:置中心点(32,32)
			敌人.显示:播放()
			table.insert(敌人组,敌人)
		end
		if(敌人产生临时>7)then
			local 敌人={
				x=-50,
				y=-50,
				d=0,
				m=2,
				移动x=0,
				移动y=0,
				攻击类型="弹幕",
				移动类型="boss型",
				血量=200*(敌人产生临时-7),
				显示= D2D_动画.创建(敌人[敌人产生临时-8],6,6,0,0,64,64),
				临时=500,
				状态=引擎:取随机整数(-180,0),
				类型=敌人产生临时
			}
			敌人.显示:置中心点(32,32)
			敌人.显示:播放()
			table.insert(敌人组,敌人)
		end
		
		
		敌人产生时间=关卡时间
		敌人产生临时2=50*tonumber(读配置项("Dat/配置2.ini",tostring(当前关卡),tostring(敌人系数-1)))
	end
	
	----敌人显示
	for n=1,table.getn(敌人组) do
		
		--特殊状态
		if(敌人组[n].类型>=6)then
			敌人组[n].显示:更新(时间)
		end
		--移动
		if(敌人组[n].移动类型=="直线飞行")and(敌人组[n].临时>=0)then
			敌人组[n].y=敌人组[n].y+1
			敌人组[n].临时=敌人组[n].临时-1
			if(敌人组[n].y>650)then
				table.remove(敌人组,n)
				break
			end
		end
		if(敌人组[n].移动类型=="静止")then
			if(敌人组[n].x<300)then
				敌人组[n].临时=敌人组[n].x+100
				敌人组[n].移动类型="飞入"
				敌人组[n].x=-100
			end
			if(敌人组[n].x>500)then
				敌人组[n].临时=900-敌人组[n].x
				敌人组[n].移动类型="飞入"
				敌人组[n].x=900
			end
			if(敌人组[n].x>=300)and(敌人组[n].x<=500)then
				敌人组[n].临时=敌人组[n].y+100
				敌人组[n].移动类型="飞入"
				敌人组[n].y=-100
			end
		end
		if(敌人组[n].移动类型=="飞入")and(敌人组[n].临时>=0)then
			if(敌人组[n].x<300)then
				敌人组[n].x=敌人组[n].x+1
				敌人组[n].临时=敌人组[n].临时-1
			end
			if(敌人组[n].x>500)then
				敌人组[n].x=敌人组[n].x-1
				敌人组[n].临时=敌人组[n].临时-1
			end
			if(敌人组[n].x>=300)and(敌人组[n].x<=500)then
				敌人组[n].y=敌人组[n].y+1
				敌人组[n].临时=敌人组[n].临时-1
			end
		end
		if(敌人组[n].移动类型=="追击移动")and(敌人组[n].临时>=0)then
			敌人组[n].移动x,敌人组[n].移动y=取移动步幅(敌人组[n].d/P-90)
			敌人组[n].x=敌人组[n].x+敌人组[n].移动x*1.7
			敌人组[n].y=敌人组[n].y+敌人组[n].移动y*1.7
			敌人组[n].临时=敌人组[n].临时-1
			if(敌人组[n].临时==0)then
				敌人组[n].d=(取两点间角度(敌人组[n].x,敌人组[n].y,主角.x,主角.y)+90)*P
			end
		end
		if(敌人组[n].移动类型=="左右飞行")and(敌人组[n].临时>=0)then
			if(敌人组[n].状态==1)then
				敌人组[n].x=敌人组[n].x-2
				敌人组[n].临时=敌人组[n].临时-2
			end
			if(敌人组[n].状态==0)then
				敌人组[n].x=敌人组[n].x+2
				敌人组[n].临时=敌人组[n].临时-2
			end
		end
		if(敌人组[n].移动类型=="boss型")and(敌人组[n].临时>=0)then
			敌人组[n].移动x,敌人组[n].移动y=取移动步幅(敌人组[n].状态)
			敌人组[n].x=400+敌人组[n].移动x*敌人组[n].临时
			敌人组[n].y=100+敌人组[n].移动y*敌人组[n].临时
			敌人组[n].临时=敌人组[n].临时-1
			if(敌人组[n].临时==0)then
				敌人组[n].状态=0
			end
		end
		
		
		
		--攻击
		if(敌人组[n].临时<0)then
			--变身
			if(敌人组[n].攻击类型=="变身")then
				if(敌人组[n].移动类型=="")then
					敌人组[n].状态=敌人组[n].状态-1
					if(敌人组[n].状态<0)then
						敌人组[n].显示:置当前帧(1)
						敌人组[n].d=(取两点间角度(敌人组[n].x,敌人组[n].y,主角.x,主角.y)+90)*P
						if(敌人组[n].类型==3)then
							敌人组[n].攻击类型="冲撞"
							敌人组[n].状态=200
						end
						if(敌人组[n].类型==4)then
							敌人组[n].攻击类型="发子弹2"
						end
						if(敌人组[n].类型==5)then
							敌人组[n].攻击类型="激光发射"
						end
					end
				else
					变身音效:播放_高级(50,false,1)
					local 临时特效={x=敌人组[n].x,y=敌人组[n].y,d=0,m=0,精灵=D2D_精灵.创建(特效图片,0,0,100,100)}
					临时特效.精灵:置中心点(50,50)
					table.insert(变身特效组,临时特效)
					敌人组[n].移动类型=""
					敌人组[n].状态=20	
				end 
			end
			--冲撞
			if(敌人组[n].攻击类型=="冲撞")then
				敌人组[n].移动x,敌人组[n].移动y=取移动步幅(敌人组[n].d/P-90)
				敌人组[n].x=敌人组[n].x+敌人组[n].移动x*4
				敌人组[n].y=敌人组[n].y+敌人组[n].移动y*4
				敌人组[n].状态=敌人组[n].状态-1
				if(敌人组[n].状态<0)then
					table.remove(敌人组,n)
					break
				end
			end
			if(敌人组[n].攻击类型=="激光发射")then
				敌人组[n].d=(取两点间角度(敌人组[n].x,敌人组[n].y,主角.x,主角.y)+90)*P
				敌人组[n].状态=120
				local 临时特效={x=敌人组[n].x,y=敌人组[n].y,d=0,d2=敌人组[n].d,m=120,精灵=D2D_精灵.创建(特效图片,0,0,100,100),炮弹=D2D_精灵.创建(激光图片,0,0,40,100)}
				临时特效.精灵:置中心点(50,50)
				临时特效.炮弹:置中心点(20,100)
				table.insert(激光特效组,临时特效)
				敌人组[n].攻击类型="激光"
			end
			if(敌人组[n].攻击类型=="激光")then
				敌人组[n].移动x,敌人组[n].移动y=取移动步幅(敌人组[n].d/P-90)
				敌人组[n].状态=敌人组[n].状态-1
				if(敌人组[n].状态<0)then
					敌人组[n].临时=200
					敌人组[n].移动类型="追击移动"
					敌人组[n].攻击类型="激光发射"
				end
			end
			if(敌人组[n].攻击类型=="发子弹1")then
				local 临时子弹={
					x2=0,
					y2=0,
					x=敌人组[n].x,
					y=敌人组[n].y,
					d=取两点间角度(敌人组[n].x,敌人组[n].y,主角.x,主角.y),
					类型=D2D_精灵.创建(子弹图片1,0,0,16,16),
					攻击力=1,
					射程=400
				}
				临时子弹.类型:置中心点(16,16)
				table.insert(敌人子弹组,临时子弹)
				敌人组[n].临时=引擎:取随机整数(100,200)
				子弹音效1:播放()
			end
			if(敌人组[n].攻击类型=="发子弹2")then
				if(敌人组[n].状态<0)then
					敌人组[n].状态=引擎:取随机整数(12,18)
					敌人组[n].攻击类型="就绪发子弹2"
				else
					敌人组[n].状态=敌人组[n].状态-0.05
				end
			end
			if(敌人组[n].攻击类型=="就绪发子弹2")then
				for  m=1,敌人组[n].状态 do
					local 临时子弹={
						x2=0,
						y2=0,
						x=敌人组[n].x,
						y=敌人组[n].y,
						d=360*m/敌人组[n].状态,
						类型=D2D_精灵.创建(子弹图片2,0,0,16,16),
						攻击力=2,
						射程=600+引擎:取随机整数(-50,50)
					}
					临时子弹.类型:置中心点(16,16)
					table.insert(敌人子弹组,临时子弹)
				end
				敌人组[n].移动类型=""
				敌人组[n].攻击类型="发子弹2"
				子弹音效3:播放()
			end
			if(敌人组[n].攻击类型=="发子弹3")then
				敌人组[n].状态=引擎:取随机整数(8,12)
				敌人组[n].攻击类型="就绪发子弹3"
			end
			if(敌人组[n].攻击类型=="就绪发子弹3")then
				for  m=1,敌人组[n].状态 do
					local 临时子弹={
						x2=0,
						y2=0,
						x=敌人组[n].x,
						y=敌人组[n].y,
						d=180*m/敌人组[n].状态,
						类型=D2D_精灵.创建(子弹图片1,0,0,16,16),
						攻击力=2,
						射程=600+引擎:取随机整数(-50,50)
					}
					临时子弹.类型:置颜色(ARGB(255,255,50,0))
					临时子弹.类型:置中心点(16,16)
					table.insert(敌人子弹组,临时子弹)
					子弹音效3:播放()
				end
				if(敌人组[n].x<=400)then
					敌人组[n].状态=0
				else
					敌人组[n].状态=1
				end
				敌人组[n].移动类型="左右飞行"
				敌人组[n].攻击类型="发子弹3"
				敌人组[n].临时=引擎:取随机整数(100,200)
			end
			if(敌人组[n].攻击类型=="弹幕")and(table.getn(弹幕特效组)==0)then
				if(敌人组[n].状态<0)then
					local 临时弹幕={
						x2=0,
						y2=0,
						x=敌人组[n].x,
						y=敌人组[n].y,
						d=取两点间角度(敌人组[n].x,敌人组[n].y,主角.x,主角.y)+引擎:取随机小数(-0.2,0.2),
						类型=D2D_精灵.创建(特效图片,0,0,100,100),
						射程=引擎:取随机整数(200,300),
						临时=0,
						等级=敌人组[n].类型-7
					}
					临时弹幕.类型:置中心点(50,50)
					table.insert(弹幕特效组,临时弹幕)
					敌人组[n].状态=引擎:取随机整数(100,200)
				else
					敌人组[n].状态=敌人组[n].状态-0.5
				end
			end
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
		end
		
		--击中判断
		for r=1,table.getn(主角子弹组) do
			if(((敌人组[n].x-主角子弹组[r].x)*(敌人组[n].x-主角子弹组[r].x)+(敌人组[n].y-主角子弹组[r].y)*(敌人组[n].y-主角子弹组[r].y))<2500)then
				local 临时爆炸={
					x=敌人组[n].x+引擎:取随机整数(-10,10),
					y=敌人组[n].y+引擎:取随机整数(-10,10),
					类型=D2D_粒子.创建("Dat/爆炸.psi",爆炸),
					倒计时=25
				}
				table.insert(爆炸特效组,临时爆炸)
				敌人组[n].血量=敌人组[n].血量-主角子弹组[r].威力
				table.remove(主角子弹组,r)
				break
			end
			
		end
		for r2=1,table.getn(卫星子弹组) do
			if(((敌人组[n].x-卫星子弹组[r2].x)*(敌人组[n].x-卫星子弹组[r2].x)+(敌人组[n].y-卫星子弹组[r2].y)*(敌人组[n].y-卫星子弹组[r2].y))<2500)then
				local 临时爆炸={
					x=敌人组[n].x+引擎:取随机整数(-10,10),
					y=敌人组[n].y+引擎:取随机整数(-10,10),
					类型=D2D_粒子.创建("Dat/爆炸.psi",爆炸),
					倒计时=25
				}
				table.insert(爆炸特效组,临时爆炸)
				敌人组[n].血量=敌人组[n].血量-卫星子弹组[r2].威力
				table.remove(卫星子弹组,r2)
				break
			end
		end
		
		--撞死判断
		
		if(((敌人组[n].x-主角.x)*(敌人组[n].x-主角.x)+(敌人组[n].y-主角.y)*(敌人组[n].y-主角.y))<2500)then
			敌人组[n].血量=敌人组[n].血量-1
			主角.血量=主角.血量-1
		end
		
		
		--显示
		敌人组[n].显示:显示_高级(敌人组[n].x,敌人组[n].y,敌人组[n].d,敌人组[n].m,敌人组[n].m)
		
		if(敌人组[n].血量<0)then
			if(敌人组[n].类型>6+当前关卡)or(敌人组[n].类型==12)then
				if(当前关卡+1<=tonumber(读配置项("Dat/配置.ini","关卡上限","关卡上限")))then
					当前关卡=当前关卡+1
					游戏状态=""
					胜利音效:播放()
		
		----附加
		if(主角.子弹威力*主角.子弹等级<25)then
			if(主角.子弹等级>4)then
				主角.子弹威力=主角.子弹威力+1
				主角.子弹等级=2
			else
				主角.子弹等级=主角.子弹等级+1
			end
			主角.防御=主角.防御+0.1
		end
		--附加完
		
				else
					游戏状态="胜利"
				end
			end
			local 临时爆炸={
				x=敌人组[n].x+引擎:取随机整数(-10,10),
				y=敌人组[n].y+引擎:取随机整数(-10,10),
				类型=D2D_粒子.创建("Dat/大爆炸.psi",爆炸),
				倒计时=25
			}
			血量=血量+2
			table.insert(爆炸特效组,临时爆炸)
			爆炸音效:播放()
			table.remove(敌人组,n)
			break
		end
		
		
		
	end
	
	--敌人子弹
	for n=1,table.getn(敌人子弹组) do
		敌人子弹组[n].类型:显示_高级(敌人子弹组[n].x,敌人子弹组[n].y,敌人子弹组[n].d*P,1,1)
		敌人子弹组[n].x2,敌人子弹组[n].y2=取移动步幅(敌人子弹组[n].d)
		if(敌人子弹组[n].射程>0)then
			敌人子弹组[n].x=敌人子弹组[n].x+敌人子弹组[n].x2*4
			敌人子弹组[n].y=敌人子弹组[n].y+敌人子弹组[n].y2*4
			敌人子弹组[n].射程=敌人子弹组[n].射程-4
		else
			table.remove(敌人子弹组,n)
			break
		end
		--命中判断--
		if(防盾==0)and(主角包围盒:检测_点(敌人子弹组[n].x,敌人子弹组[n].y))then
		local 临时爆炸={
				x=主角.x+引擎:取随机整数(-10,10),
				y=主角.y+引擎:取随机整数(-10,10),
				类型=D2D_粒子.创建("Dat/爆炸.psi",爆炸),
				倒计时=25
			}
			table.insert(爆炸特效组,临时爆炸)
			主角.血量=主角.血量-敌人子弹组[n].攻击力/主角.防御
			table.remove(敌人子弹组,n)
			break
		end
		
	end
	
	----战斗特效
	for n=1,table.getn(变身特效组) do
		变身特效组[n].精灵:显示_高级(变身特效组[n].x,变身特效组[n].y,变身特效组[n].d,变身特效组[n].m,变身特效组[n].m)
		变身特效组[n].d=变身特效组[n].d+引擎:取随机小数(0,1)
		变身特效组[n].m=变身特效组[n].m+0.05
		变身特效组[n].精灵:置颜色(ARGB(引擎:取随机整数(100,200),引擎:取随机整数(0,255),引擎:取随机整数(0,255),引擎:取随机整数(0,255)))
		if(变身特效组[n].m>1)then
			table.remove(变身特效组,n)
			break
		end
	end
	for n=1,table.getn(激光特效组) do
		if(激光特效组[n].m<80)then
			激光特效组[n].炮弹:显示_高级(激光特效组[n].x,激光特效组[n].y,激光特效组[n].d2,引擎:取随机小数(0,1),8)
			激光特效组[n].精灵:显示_高级(激光特效组[n].x,激光特效组[n].y,激光特效组[n].d,0.7,0.7)
		else
			激光特效组[n].精灵:显示_高级(激光特效组[n].x,激光特效组[n].y,激光特效组[n].d,1.5,1.5)
		end
		激光特效组[n].d=激光特效组[n].d+引擎:取随机小数(0,1)
		激光特效组[n].m=激光特效组[n].m-1
		激光特效组[n].精灵:置颜色(ARGB(引擎:取随机整数(180,240),引擎:取随机整数(200,255),引擎:取随机整数(100,200),引擎:取随机整数(0,100)))
		if(激光特效组[n].m<0)then
			table.remove(激光特效组,n)
			break
		end
		if(激光特效组[n].m==60)then
			激光音效:播放_高级(100,false,1)
		end
		--命中判断--
		if(防盾==0)and((取两点间角度(激光特效组[n].x,激光特效组[n].y,主角.x,主角.y)+83)*P<激光特效组[n].d2)and((取两点间角度(激光特效组[n].x,激光特效组[n].y,主角.x,主角.y)+97)*P>激光特效组[n].d2)then
			if(激光特效组[n].m==60)then
				主角.血量=主角.血量-3/主角.防御
				--爆炸效果
				for r=1,4 do
					local 临时爆炸={
						x=主角.x+引擎:取随机整数(-20,20),
						y=主角.y+引擎:取随机整数(-20,20),
						类型=D2D_粒子.创建("Dat/爆炸.psi",爆炸),
						倒计时=25
					}
				table.insert(爆炸特效组,临时爆炸)
				end
			end
			if(激光特效组[n].m<80)then
				主角.血量=主角.血量-0.02/主角.防御
			end
		end
	end
	for n=1,table.getn(弹幕特效组) do
		if(弹幕特效组[n].临时==0)then
			弹幕特效组[n].类型:显示_高级(弹幕特效组[n].x,弹幕特效组[n].y,弹幕特效组[n].d*P,0.6,0.6)
		elseif(弹幕特效组[n].临时>4)then
			弹幕特效组[n].类型:显示_高级(弹幕特效组[n].x,弹幕特效组[n].y,弹幕特效组[n].d*P,1.2,1.2)
		else
			弹幕特效组[n].类型:显示_高级(弹幕特效组[n].x,弹幕特效组[n].y,弹幕特效组[n].d*P,0.3,0.3)
		end
		弹幕特效组[n].d=弹幕特效组[n].d+引擎:取随机小数(0,1)
		弹幕特效组[n].类型:置颜色(ARGB(引擎:取随机整数(100,200),引擎:取随机整数(0,255),引擎:取随机整数(0,255),引擎:取随机整数(0,255)))
		if(弹幕特效组[n].临时==0)then
			弹幕特效组[n].x2,弹幕特效组[n].y2=取移动步幅(弹幕特效组[n].d)
			if(弹幕特效组[n].射程>0)then
				弹幕特效组[n].x=弹幕特效组[n].x+弹幕特效组[n].x2*4
				弹幕特效组[n].y=弹幕特效组[n].y+弹幕特效组[n].y2*4
				弹幕特效组[n].射程=弹幕特效组[n].射程-4
			else
				弹幕特效组[n].临时=弹幕特效组[n].等级+引擎:取随机整数(0,1)
				弹幕特效组[n].d=0
				弹幕特效组[n].x2=0
				弹幕特效组[n].y2=0
			end
		end
		if(弹幕特效组[n].临时==-1)then
			table.remove(弹幕特效组,n)
			break
		end
		--变化--
		if(弹幕特效组[n].临时==1)then
			if(弹幕特效组[n].d<0)then
				local 临时子弹={
					x2=0,
					y2=0,
					x=弹幕特效组[n].x,
					y=弹幕特效组[n].y,
					d=取两点间角度(弹幕特效组[n].x,弹幕特效组[n].y,主角.x,主角.y),
					类型=D2D_精灵.创建(子弹图片1,0,0,16,16),
					攻击力=2,
					射程=500
				}
				临时子弹.类型:置中心点(16,16)
				table.insert(敌人子弹组,临时子弹)
				子弹音效1:播放()
				弹幕特效组[n].x2=弹幕特效组[n].x2+1
				if(弹幕特效组[n].x2>16)then
					弹幕特效组[n].临时=-1
				end
				弹幕特效组[n].d=10
			else
				弹幕特效组[n].d=弹幕特效组[n].d-1
			end
		end
		if(弹幕特效组[n].临时==2)then
			if(弹幕特效组[n].d<0)then
				local 临时子弹={
					x2=0,
					y2=0,
					x=弹幕特效组[n].x,
					y=弹幕特效组[n].y,
					d=弹幕特效组[n].x2*30,
					类型=D2D_精灵.创建(子弹图片2,0,0,16,16),
					攻击力=1,
					射程=500+引擎:取随机整数(-50,50)
				}
				临时子弹.类型:置中心点(16,16)
				table.insert(敌人子弹组,临时子弹)
				子弹音效1:播放()
				弹幕特效组[n].x2=弹幕特效组[n].x2+1
				if(弹幕特效组[n].x2>=47)then
					弹幕特效组[n].临时=-1
				end
				弹幕特效组[n].d=0
			else
				弹幕特效组[n].d=弹幕特效组[n].d-1
			end
		end
		if(弹幕特效组[n].临时==3)then
			if(弹幕特效组[n].d<0)then
				local 临时子弹={
					x2=0,
					y2=0,
					x=弹幕特效组[n].x+引擎:取随机整数(-20,20),
					y=弹幕特效组[n].y+引擎:取随机整数(-20,20),
					d=取两点间角度(弹幕特效组[n].x,弹幕特效组[n].y,主角.x,主角.y),
					类型=D2D_精灵.创建(子弹图片2,0,0,16,16),
					攻击力=2,
					射程=500+引擎:取随机整数(-50,50)
				}
				临时子弹.类型:置中心点(16,16)
				table.insert(敌人子弹组,临时子弹)
				子弹音效1:播放()
				弹幕特效组[n].x2=弹幕特效组[n].x2+1
				if(弹幕特效组[n].x2>30)then
					弹幕特效组[n].临时=-1
				end
				弹幕特效组[n].d=0
			else
				弹幕特效组[n].d=弹幕特效组[n].d-1
			end
		end
		if(弹幕特效组[n].临时==4)then
			if(弹幕特效组[n].d<0)then
				local 临时子弹={
					x2=0,
					y2=0,
					x=弹幕特效组[n].x+引擎:取随机整数(-20,20),
					y=弹幕特效组[n].y+引擎:取随机整数(-20,20),
					d=弹幕特效组[n].x2*30,
					类型=D2D_精灵.创建(子弹图片2,0,0,16,16),
					攻击力=2,
					射程=500+引擎:取随机整数(-50,50)
				}
				临时子弹.类型:置中心点(16,16)
				table.insert(敌人子弹组,临时子弹)
				子弹音效1:播放()
				弹幕特效组[n].x2=弹幕特效组[n].x2+1
				if(弹幕特效组[n].x2==35)then
					弹幕特效组[n].y=引擎:取随机整数(100,500)
					弹幕特效组[n].x=引擎:取随机整数(100,700)
				end
				if(弹幕特效组[n].x2>70)then
					弹幕特效组[n].临时=-1
				end
				弹幕特效组[n].d=0
			else
				弹幕特效组[n].d=弹幕特效组[n].d-1
			end
		end
		if(弹幕特效组[n].临时==5)then
			临时x,临时y=取移动步幅(取两点间角度(主角.x,主角.y,弹幕特效组[n].x,弹幕特效组[n].y))
			主角.x=主角.x+临时x*2
			主角.y=主角.y+临时y*2
			if(弹幕特效组[n].d<0)then
				local 临时子弹={
					x2=0,
					y2=0,
					x=弹幕特效组[n].x,
					y=弹幕特效组[n].y,
					d=弹幕特效组[n].x2*30,
					类型=D2D_精灵.创建(子弹图片2,0,0,16,16),
					攻击力=3,
					射程=500+引擎:取随机整数(-50,150)
				}
				临时子弹.类型:置中心点(16,16)
				table.insert(敌人子弹组,临时子弹)
				子弹音效1:播放()
				local 临时子弹={
					x2=0,
					y2=0,
					x=弹幕特效组[n].x,
					y=弹幕特效组[n].y,
					d=375-弹幕特效组[n].x2*30,
					类型=D2D_精灵.创建(子弹图片1,0,0,16,16),
					攻击力=3,
					射程=500+引擎:取随机整数(-50,150)
				}
				临时子弹.类型:置颜色(ARGB(255,255,0,100))
				临时子弹.类型:置中心点(16,16)
				table.insert(敌人子弹组,临时子弹)
				弹幕特效组[n].x2=弹幕特效组[n].x2+1
				if(弹幕特效组[n].x2%16==0)then
					弹幕特效组[n].y=引擎:取随机整数(100,500)
					弹幕特效组[n].x=引擎:取随机整数(100,700)
				end
				if(弹幕特效组[n].x2>63)then
					弹幕特效组[n].临时=-1
				end
				弹幕特效组[n].d=0
			else
				弹幕特效组[n].d=弹幕特效组[n].d-1
			end
		end
		if(弹幕特效组[n].临时==6)then
			临时x,临时y=取移动步幅(取两点间角度(主角.x,主角.y,弹幕特效组[n].x,弹幕特效组[n].y))
			主角.x=主角.x+临时x*2
			主角.y=主角.y+临时y*2
			if(弹幕特效组[n].d<0)then
				local 临时子弹={
					x2=0,
					y2=0,
					x=弹幕特效组[n].x+引擎:取随机整数(-20,20),
					y=弹幕特效组[n].y+引擎:取随机整数(-20,20),
					d=取两点间角度(弹幕特效组[n].x,弹幕特效组[n].y,主角.x,主角.y),
					类型=D2D_精灵.创建(子弹图片1,0,0,16,16),
					攻击力=3,
					射程=500+引擎:取随机整数(-50,50)
				}
				临时子弹.类型:置颜色(ARGB(255,255,0,100))
				临时子弹.类型:置中心点(16,16)
				table.insert(敌人子弹组,临时子弹)
				子弹音效1:播放()
				弹幕特效组[n].x2=弹幕特效组[n].x2+1
				if(弹幕特效组[n].x2%10==0)then
					弹幕特效组[n].y=引擎:取随机整数(100,500)
					弹幕特效组[n].x=引擎:取随机整数(100,700)
				end
				if(弹幕特效组[n].x2>70)then
					弹幕特效组[n].临时=-1
				end
				弹幕特效组[n].d=0
			else
				弹幕特效组[n].d=弹幕特效组[n].d-1
			end
		end
		
		
	end
		----战斗代码完
	end
	
	
	for n=1,table.getn(爆炸特效组) do
		爆炸特效组[n].类型:启动到(爆炸特效组[n].x,爆炸特效组[n].y)
		爆炸特效组[n].类型:更新(时间)
		爆炸特效组[n].类型:显示(爆炸特效组[n].x,爆炸特效组[n].y)
		爆炸特效组[n].倒计时=爆炸特效组[n].倒计时-1
		if(爆炸特效组[n].倒计时<0)then
			table.remove(爆炸特效组,n)
			break
		end
	end

	
	渲染结束()
	return false
end









--===============================================================================
-- ■ 网络数据处理()
--===============================================================================
function 网络数据处理 (命令,参数1,参数2,附加)


end




--=============================================================================--
-- ■ 网络连接断开()
--=============================================================================--
function 网络连接断开 ()


end



--===============================================================================
-- ■ 屏幕获得焦点()
--===============================================================================
function 屏幕获得焦点 ()


	return false
end



--===============================================================================
-- ■ 屏幕失去焦点()
--===============================================================================
function 屏幕失去焦点 ()


	return false
end



--===============================================================================
-- ■ 屏幕关闭()
--===============================================================================
function 屏幕关闭 ()

	
	
	return true
end



--===============================================================================
-- ■ 渲染区保护()
--===============================================================================
function 渲染区保护 ()


	return false
end








